package com.zhiyou100.api.list_demo;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * 判断元素： isEmpty   contains
 * 查询元素的索引位置：indexOf  lastIndexOf
 * 获取集合的大小（长度）:size()
 * 集合转数组：toArray
 * 集合的截取：subList
 * 集合的排序：sort(Comparator c)   jdk 1.8 新方法
 * Comparator：比较器接口，它内部提供的有一个compare方法，用于定义比较规则
 * 集合的遍历:
 * for: 常规循环
 * foreach: 增强for循环
 * Iterator： 迭代器
 * forEach()： java8提供的新方法
 * stream: java8提供的新操作方式
 */
public class Demo1 {

    public static void main(String[] args) {
        test8();
    }


    /**
     * forEach()： java8提供的新方法
     */
    public static void test8() {
        Student stu1 = new Student("jack", 20);
        Student stu2 = new Student("tom", 21);
        Student stu3 = new Student("rose", 19);
        Student stu4 = new Student("lucy", 25);
        List<Student> studentList = Arrays.asList(stu1, stu2, stu3, stu4);

//        studentList.forEach(student -> System.out.println(student));
        //调动forEach方法
        studentList.forEach(new Consumer<Student>() {
            //accept 中的形参就是集合中的元素
            @Override
            public void accept(Student student) {
                System.out.println(student);
                student.setAge(student.getAge() + 2);
            }
        });
        System.out.println(studentList);
        //以流的形式进行操作
//        studentList.stream().forEach(student -> System.out.println(student));

    }

    /**
     * 使用迭代器遍历
     */
    public static void test7() {
        Student stu1 = new Student("jack", 20);
        Student stu2 = new Student("tom", 21);
        Student stu3 = new Student("rose", 19);
        Student stu4 = new Student("lucy", 25);
        List<Student> studentList = Arrays.asList(stu1, stu2, stu3, stu4);
        //将集合对象转换成迭代器对象
        Iterator<Student> iterator = studentList.iterator();
        //循环将迭代器中的元素获取
        //hasNext()   迭代器默认有个指针，位于第一个元素之前，当调用hasNext，指针会向下移动，如果此时有数据，就返回true
//        boolean b = iterator.hasNext();
        while (iterator.hasNext()) {
            //获取迭代器中的数据
            Student student = iterator.next();
            System.out.println("student = " + student);
        }
    }

    /**
     * 集合的遍历
     */
    public static void test6() {
        Student stu1 = new Student("jack", 20);
        Student stu2 = new Student("tom", 21);
        Student stu3 = new Student("rose", 19);
        Student stu4 = new Student("lucy", 25);
        List<Student> studentList = Arrays.asList(stu1, stu2, stu3, stu4);
        //List集合是根据索引操作的
        for (int i = 0; i < studentList.size(); i++) {
            System.out.println(studentList.get(i));
        }
        System.out.println("----------增强for-------------");
        //利用foreach增强for循环
        for (Student stu : studentList) {
            System.out.println(stu);
        }
    }

    /**
     * 排序：但是List集合中保存的元素是学生对象
     */
    public static void test5() {
        Student stu1 = new Student("jack", 20);
        Student stu2 = new Student("tom", 21);
        Student stu3 = new Student("rose", 19);
        Student stu4 = new Student("lucy", 25);
//        List<Student> stus = new ArrayList<>();
        List<Student> stus = Arrays.asList(stu1, stu2, stu3, stu4);
        System.out.println("stus = " + stus);
        //将stus集合进行排序，根据学生的年龄升序
        stus.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //此处定义比较规则
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println("排序后的结果 = " + stus);

    }


    /**
     * 集合的排序： sort()
     * 1、将当前集合转数组
     * 2、调用数组的排序功能
     * 3、将排序好的数组转换成集合返回给用户
     */
    public static void test4() {
        List<Integer> list = Arrays.asList(78, 89, 56, 84, 67, 77, 99);
        list.sort(new Comparator<Integer>() {
            //这个compare定义的就是数据比较规则，这两个形参表示的就是我们要比较的数据
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println("list = " + list);
    }


    //获取集合的长度以及集合转数组、集合的截取
    public static void test3() {
        List<Double> scores = Arrays.asList(70.5, 56.8, 89.9, 78.2, 32.5);
        //获取长度
        int size = scores.size();
        System.out.println("size = " + size);
        //集合转数组
        Object[] array = scores.toArray();
        System.out.println(Arrays.toString(array));
        Double[] d = new Double[scores.size()];
        d = scores.toArray(d);
        System.out.println(Arrays.toString(d));
        //集合的截取   会获取一个新的集合   [from,to）
        List<Double> list = scores.subList(1, 4);
        System.out.println(list);
    }

    //查询元素的索引位置：
    public static void test2() {
        ArrayList<Double> scores = new ArrayList<>();
        scores.add(70.5);
        scores.add(56.9);
        scores.add(65.9);
        scores.add(69.9);
        scores.add(69.9);
        scores.add(65.9);
        //查找元素的位置   从前往后找
        int i = scores.indexOf(65.9);
        System.out.println("i = " + i); // 2
        //从后往前找
        int index = scores.lastIndexOf(69.9); //4
        System.out.println("index = " + index);
    }

    public static void test1() {
        ArrayList<Double> scores = new ArrayList<>();
        scores.add(70.5);
        //判断当前集合是否为空
        boolean b = scores.isEmpty();
        System.out.println("b = " + b);
        //如果当前集合为空，我们就添加数据
        if (b) {
            //添加元素
            scores.add(56.9);
            scores.add(65.9);
            scores.add(69.9);
        } else {
            if (scores.contains(70.5)) {
                //判断当前集合中是否包含70.5这个元素，如果包含，将其更新为82.5
                //查找元素的位置   从前往后找
                int i = scores.indexOf(70.5);
                System.out.println("i = " + i);
                //修改元素
                scores.set(i, 82.5);
            } else {
                scores.add(70.5);
            }
        }
        System.out.println(scores);
    }


    /**
     * ArrayList集合的基本操作
     */
    public static void basicOpe() {
        //可以利用多态创建集合对象
//        List<Double> scores = new ArrayList<>();
        //创建一个空集合，表示成绩  元素Double类型
        ArrayList<Double> scores = new ArrayList<>();
        //添加元素
        scores.add(56.9);
        scores.add(65.9);
        scores.add(69.9);
        System.out.println("添加后的数据：" + scores);
        //查看元素  根据下标（索引）
        double score = scores.get(0);
        System.out.println("score = " + score);  //56.9
        score = scores.get(2);
        System.out.println("score = " + score);
        //修改元素    根据索引修改元素
        scores.set(1, 78.5);
        System.out.println("修改后的集合：" + scores);
        //在指定位置添加元素   插入元素
        scores.add(1, 80.0);
        System.out.println("原索引为1的元素往后移动了一位之后：" + scores);
        //移除元素  根据索引   返回值表示要删除的元素
        scores.remove(2);
        System.out.println("删除之后的集合元素有：" + scores);
        //根据元素移除  从前往后，遇到符合条件的元素就删除结束  返回值表示删除成功或失败
        scores.add(80.0);
        scores.add(80.0);
        System.out.println("重复添加数据后的集合：" + scores);
        boolean b = scores.remove(80.0);
        System.out.println("b = " + b);
        System.out.println("删除指定元素后的集合：" + scores);
        //自定义删除条件  进行删除   1.8提供的新方法
        scores.removeIf(new Predicate<Double>() {
            //aDouble表示的就是集合中的元素
            @Override
            public boolean test(Double aDouble) {
                //定义删除条件  只要满足的都删除
                return aDouble == 80.0;
            }
        });
//        System.out.println(scores.get(2));
        System.out.println("根据自定义条件删除后的集合" + scores);
    }


    /**
     * ArrayList集合的创建
     */
    public static void createList() {
        int[] array = new int[15];
        //创建一个初始容量为10 的空集合,如果不指定集合的元素类型，默认就是object
        ArrayList list = new ArrayList();
        //常规使用时，会指定我们的集合要保存的数据类型，通过泛型执行<类型>
        //<>表示泛型  用于约束我们集合的数据类型的
        ArrayList<Double> scores = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        //定义集合时指定集合初始容量大小  20
        ArrayList<Integer> list3 = new ArrayList<>(20);
        //将数组转成ArrayList集合   Arrays.asList
        List<Integer> list4 = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
        //根据一个已知的集合对象创建一个ArrayList集合
        HashSet set = new HashSet();
        ArrayList list5 = new ArrayList(set);
    }

}
